"""RPA框架主窗口"""

import sys
import os
from PyQt5.QtWidgets import (
    QMainWindow, QApplication, QTabWidget, QAction, QMessageBox, 
    QFileDialog, QToolBar, QDockWidget, QWidget, QVBoxLayout, QSplitter, QLabel
)
from PyQt5.QtCore import Qt, QTimer
from PyQt5.QtGui import QColor, QTextCursor, QFont

# 尝试导入GUI组件
from rpa_framework.gui.task_manager import TaskManagerWidget
from rpa_framework.gui.workflow_designer import WorkflowDesignerWidget
from rpa_framework.gui.robot_controller import RobotControllerWidget
from rpa_framework.gui.log_viewer import LogViewerWidget

# 导入核心组件
from rpa_framework.core.robot import Robot
from rpa_framework.core.workflow import Workflow
from rpa_framework.core.task import Task
# 导入配置管理器
from rpa_framework.config.config_manager import ConfigManager

# 使用标准logging模块
import logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger("rpa.gui.main_window")


class RPAMainWindow(QMainWindow):
    """RPA框架主窗口类"""
    
    def __init__(self):
        super().__init__()
        
        # 初始化机器人实例
        self.robot = None
        
        # 设置窗口标题和大小
        self.setWindowTitle("RPA框架 - 企业级机器人流程自动化平台")
        self.setGeometry(100, 100, 1200, 800)
        
        # 初始化UI组件
        self._init_ui()
        
        # 初始化状态栏
        self._init_status_bar()
        
        # 更新状态栏定时器
        self._status_timer = QTimer(self)
        self._status_timer.timeout.connect(self._update_status)
        self._status_timer.start(1000)  # 每秒更新一次
        
        # 尝试初始化ConfigManagerWidget
        try:
            from rpa_framework.gui.config_manager import ConfigManagerWidget
            # 创建ConfigManager实例
            config_manager = ConfigManager()
            # 初始化ConfigManagerWidget并传递config_manager实例
            self.configuration_manager = ConfigManagerWidget(config_manager)
            # 连接配置更改信号
            self.configuration_manager.config_saved.connect(self._on_config_saved)
            self.configuration_manager.config_loaded.connect(self._on_config_loaded)
            self.tab_widget.addTab(self.configuration_manager, "配置管理")
            logger.info("配置管理组件已成功加载")
        except Exception as e:
            logger.warning(f"无法加载配置管理组件: {e}")
            # 创建一个简单的占位符
            placeholder = QWidget()
            placeholder.setLayout(QVBoxLayout())
            placeholder.layout().addWidget(QLabel(f"配置管理组件暂不可用: {str(e)}"))
            self.tab_widget.addTab(placeholder, "配置管理 (暂不可用)")
        
        # 连接信号槽
        self._connect_signals_slots()
        
        logger.info("RPA框架主窗口初始化完成")
    
    def _init_ui(self):
        """初始化UI组件"""
        # 创建中央标签窗口
        self.tab_widget = QTabWidget()
        self.tab_widget.setTabsClosable(False)
        
        # 创建各个功能模块
        self.task_manager = TaskManagerWidget()
        self.workflow_designer = WorkflowDesignerWidget()
        self.log_viewer = LogViewerWidget()
        self.robot_controller = RobotControllerWidget()
        
        # 添加标签页
        self.tab_widget.addTab(self.robot_controller, "机器人控制")
        self.tab_widget.addTab(self.workflow_designer, "工作流设计")
        self.tab_widget.addTab(self.task_manager, "任务管理")
        self.tab_widget.addTab(self.log_viewer, "日志查看")
        
        # 设置中央窗口
        self.setCentralWidget(self.tab_widget)
        
        # 创建菜单栏
        self._init_menu_bar()
        
        # 创建工具栏
        self._init_tool_bar()
        
        # 创建停靠窗口
        self._init_dock_widgets()
    
    def _init_menu_bar(self):
        """初始化菜单栏"""
        menu_bar = self.menuBar()
        
        # 文件菜单
        file_menu = menu_bar.addMenu("文件")
        
        # 新建工作流
        new_workflow_action = QAction("新建工作流", self)
        new_workflow_action.setShortcut("Ctrl+N")
        new_workflow_action.triggered.connect(self._new_workflow)
        file_menu.addAction(new_workflow_action)
        
        # 打开工作流
        open_workflow_action = QAction("打开工作流", self)
        open_workflow_action.setShortcut("Ctrl+O")
        open_workflow_action.triggered.connect(self._open_workflow)
        file_menu.addAction(open_workflow_action)
        
        # 保存工作流
        save_workflow_action = QAction("保存工作流", self)
        save_workflow_action.setShortcut("Ctrl+S")
        save_workflow_action.triggered.connect(self._save_workflow)
        file_menu.addAction(save_workflow_action)
        
        file_menu.addSeparator()
        
        # 退出
        exit_action = QAction("退出", self)
        exit_action.setShortcut("Ctrl+Q")
        exit_action.triggered.connect(self.close)
        file_menu.addAction(exit_action)
        
        # 编辑菜单
        edit_menu = menu_bar.addMenu("编辑")
        
        # 复制
        copy_action = QAction("复制", self)
        copy_action.setShortcut("Ctrl+C")
        edit_menu.addAction(copy_action)
        
        # 粘贴
        paste_action = QAction("粘贴", self)
        paste_action.setShortcut("Ctrl+V")
        edit_menu.addAction(paste_action)
        
        # 编辑配置
        edit_config_action = QAction("编辑配置", self)
        edit_config_action.triggered.connect(
            lambda: self.tab_widget.setCurrentWidget(self.configuration_manager)
        )
        edit_menu.addAction(edit_config_action)
        
        # 工具菜单
        tools_menu = menu_bar.addMenu("工具")
        
        # 打开机器人控制器
        robot_controller_action = QAction("机器人控制器", self)
        robot_controller_action.triggered.connect(
            lambda: self.tab_widget.setCurrentWidget(self.robot_controller)
        )
        tools_menu.addAction(robot_controller_action)
        
        # 打开任务管理器
        task_manager_action = QAction("任务管理器", self)
        task_manager_action.triggered.connect(
            lambda: self.tab_widget.setCurrentWidget(self.task_manager)
        )
        tools_menu.addAction(task_manager_action)
        
        # 打开工作流设计器
        workflow_designer_action = QAction("工作流设计器", self)
        workflow_designer_action.triggered.connect(
            lambda: self.tab_widget.setCurrentWidget(self.workflow_designer)
        )
        tools_menu.addAction(workflow_designer_action)
        
        # 打开日志查看器
        log_viewer_action = QAction("日志查看器", self)
        log_viewer_action.triggered.connect(
            lambda: self.tab_widget.setCurrentWidget(self.log_viewer)
        )
        tools_menu.addAction(log_viewer_action)
        
        # 帮助菜单
        help_menu = menu_bar.addMenu("帮助")
        
        # 关于
        about_action = QAction("关于", self)
        about_action.triggered.connect(self._show_about)
        help_menu.addAction(about_action)
        
        # 使用帮助
        help_action = QAction("使用帮助", self)
        help_action.triggered.connect(self._show_help)
        help_menu.addAction(help_action)
    
    def _init_tool_bar(self):
        """初始化工具栏"""
        tool_bar = QToolBar("工具栏", self)
        self.addToolBar(tool_bar)
        
        # 启动机器人
        start_robot_action = QAction("启动机器人", self)
        start_robot_action.triggered.connect(self._start_robot)
        tool_bar.addAction(start_robot_action)
        
        # 停止机器人
        stop_robot_action = QAction("停止机器人", self)
        stop_robot_action.triggered.connect(self._stop_robot)
        tool_bar.addAction(stop_robot_action)
        
        tool_bar.addSeparator()
    
    def _init_dock_widgets(self):
        """初始化停靠窗口"""
        # 这里可以添加停靠窗口
        pass
    
    def _init_status_bar(self):
        """初始化状态栏"""
        self.statusBar().showMessage("就绪")
    
    def _start_robot(self):
        """启动机器人"""
        if self.robot is None:
            try:
                self.robot = Robot()
                self.robot.start()
                logger.info("机器人已成功启动")
                
                # 将机器人实例传递给控制器
                if hasattr(self, 'robot_controller'):
                    self.robot_controller.robot = self.robot
                    self.robot_controller._update_ui_state()
                    
                QMessageBox.information(self, "成功", "机器人已成功启动")
            except Exception as e:
                logger.error(f"启动机器人失败: {e}")
                QMessageBox.critical(self, "错误", f"启动机器人失败: {str(e)}")
    
    def _stop_robot(self):
        """停止机器人"""
        if self.robot is not None and self.robot.is_running:
            try:
                self.robot.stop()
                logger.info("机器人已成功停止")
                
                # 更新控制器状态
                if hasattr(self, 'robot_controller'):
                    self.robot_controller._update_ui_state()
                    
                QMessageBox.information(self, "成功", "机器人已成功停止")
            except Exception as e:
                logger.error(f"停止机器人失败: {e}")
                QMessageBox.critical(self, "错误", f"停止机器人失败: {str(e)}")
    
    def _new_workflow(self):
        """新建工作流"""
        self.tab_widget.setCurrentWidget(self.workflow_designer)
        # 这里可以添加创建新工作流的逻辑
    
    def _open_workflow(self):
        """打开工作流"""
        # 这里可以添加打开工作流的逻辑
        pass
    
    def _save_workflow(self):
        """保存工作流"""
        # 这里可以添加保存工作流的逻辑
        pass
    
    def _show_about(self):
        """显示关于对话框"""
        QMessageBox.about(
            self, 
            "关于RPA框架", 
            "RPA框架 - 企业级机器人流程自动化平台\n\n版本: 1.0.0\n作者: RPA团队"
        )
    
    def _show_help(self):
        """显示帮助对话框"""
        QMessageBox.information(
            self, 
            "使用帮助", 
            "请参考RPA框架使用文档获取详细的使用说明。"
        )
    
    def _connect_signals_slots(self):
        """连接信号槽"""
        # 连接机器人控制器信号
        if hasattr(self, 'robot_controller'):
            self.robot_controller.robot_started.connect(self._on_robot_started)
            self.robot_controller.robot_stopped.connect(self._on_robot_stopped)
            self.robot_controller.robot_error.connect(self._on_robot_error)
        
        # 连接任务管理器信号
        if hasattr(self, 'task_manager'):
            self.task_manager.task_execution_requested.connect(self._on_task_execution_requested)
        
    def _on_robot_started(self, robot):
        """机器人启动时的处理"""
        self.robot = robot
        logger.info("机器人已通过控制器启动")
        
    def _on_robot_stopped(self):
        """机器人停止时的处理"""
        logger.info("机器人已通过控制器停止")
        
    def _on_robot_error(self, error_msg):
        """机器人错误时的处理"""
        logger.error(f"机器人错误: {error_msg}")
        QMessageBox.critical(self, "机器人错误", error_msg)
        
    def _on_task_execution_requested(self, task_id):
        """任务执行请求处理"""
        if self.robot and self.robot.is_running:
            # 从任务管理器获取任务
            task = self.task_manager.get_task(task_id=task_id)
            if task:
                try:
                    # 使用机器人执行任务
                    result = self.robot.execute_task(task.action, *task.args, **task.kwargs)
                    QMessageBox.information(self, "成功", f"任务 '{task.name}' 执行成功")
                except Exception as e:
                    QMessageBox.critical(self, "错误", f"任务执行失败: {str(e)}")
            else:
                QMessageBox.warning(self, "警告", "未找到指定的任务")
        else:
            QMessageBox.warning(self, "警告", "机器人未启动，请先启动机器人")
    
    def _on_config_saved(self, config_path):
        """配置保存后的处理"""
        logger.info(f"配置已保存到: {config_path}")
        # 可以在这里更新其他组件的配置
        self.statusBar().showMessage(f"配置已保存: {os.path.basename(config_path)}")
    
    def _on_config_loaded(self, config_path):
        """配置加载后的处理"""
        logger.info(f"配置已从: {config_path} 加载")
        # 可以在这里更新其他组件的配置
        self.statusBar().showMessage(f"配置已加载: {os.path.basename(config_path)}")
    
    def _update_status(self):
        """更新状态栏"""
        status_text = "就绪"
        if self.robot and self.robot.is_running:
            status_text = "机器人运行中"
            # 显示任务统计
            if hasattr(self.robot, 'tasks_executed'):
                status_text += f" - 任务: {self.robot.tasks_executed}执行, "
                success_count = self.robot.tasks_executed - self.robot.tasks_failed
                status_text += f"{success_count}成功, {self.robot.tasks_failed}失败"
        
        self.statusBar().showMessage(status_text)
    
    def closeEvent(self, event):
        """窗口关闭事件"""
        # 如果机器人正在运行，提示用户停止机器人
        if self.robot and self.robot.is_running:
            reply = QMessageBox.question(
                self, "确认关闭", 
                "机器人正在运行，确定要关闭窗口吗？",
                QMessageBox.Yes | QMessageBox.No, QMessageBox.No
            )
            if reply == QMessageBox.Yes:
                self.robot.stop()
                event.accept()
            else:
                event.ignore()
        else:
            event.accept()


def run_gui():
    """运行RPA框架GUI"""
    try:
        # 创建应用程序实例
        app = QApplication(sys.argv)
        
        # 设置应用程序样式
        app.setStyle("Fusion")
        
        # 创建并显示主窗口
        main_window = RPAMainWindow()
        main_window.show()
        
        # 运行应用程序
        sys.exit(app.exec())
    except Exception as e:
        logger.critical(f"GUI启动失败: {e}")
        raise


if __name__ == "__main__":
    run_gui()